const app = getApp();
Page({
  data: {
    userId: wx.getStorageSync('userId'), // 当前用户ID
    chatId: null, // 聊天对象ID
    chatNickname: '', // 聊天标题
    selfAvatar: wx.getStorageSync('avatarUrl'), //自己头像
    chatAvatar: '', //对方头像
    onlineStatus: 0, // 在线状态
    messages: [], // 聊天消息列表
    inputValue: '', // 输入框内容
    timers: {}, // 用于存储各消息的定时器
    scrollToId: "", // 新增滚动锚点ID
    keyboardHeight: 0, // 新增键盘高度状态
    messageListener: null,
    systemListener: null,
  },

  onLoad(options) {
    // 获取上个页面传递的参数
    const {
      chatAvatar,
      chatId,
      name,
      online,
    } = options;

    console.log("当前用户ID:", this.data.userId);
    console.log("会话ID:", chatId);

    // 更新data数据
    this.setData({
      chatId: chatId,
      chatAvatar: chatAvatar,
      chatNickname: name,
      onlineStatus: online
    });

    // 初始化聊天（获取历史消息）
    this.initChat();

    //初始化消息监听器
    this.initListener();
  },

  onUnload() {
    // 移除监听器
    app.removeMessageListener(this.data.messageListener);
    app.removeSystemMessageListener(this.data.systemListener);
    wx.offKeyboardHeightChange();
  },

  //初始化消息监听器
  initListener() {
    // 注册普通消息监听器
    this.data.messageListener = (data) => this.handleReceivedMessage(data);
    app.addMessageListener(this.data.messageListener);
    // 注册系统消息监听器
    this.data.systemListener = (data) => this.handleSystemMessage(data);
    app.addSystemMessageListener(this.data.systemListener);
    // 监听键盘高度变化
    wx.onKeyboardHeightChange(res => {
      this.setData({
        keyboardHeight: res.height
      }, () => {
        this.scrollToBottom(); // 键盘弹出时自动滚动到底部
      });
    });
  },

  // 初始化聊天（http获取历史消息）
  initChat() {
    const {
      userId,
      chatId
    } = this.data;
    // 请求后端获取历史消息
    wx.request({
      url: `${app.globalData.baseUrl}/api/user/message/msgs`, // 替换为你的后端接口
      method: 'GET',
      data: {
        userId,
        chatId,
      },
      success: (res) => {
        if (res.data?.data) {
          let id = 0;
          let previousTime = null; // 用于记录上一条消息的时间

          const messages = res.data.data.map((msg, index) => {
            const formattedTime = this.formatServerTime(msg.time); // 格式化时间
            const currentTime = msg.time ? new Date(...msg.time).getTime() : null; // 当前消息的时间戳

            // 判断是否需要显示时间
            const showTime =
              previousTime === null || // 第一条消息总是显示时间
              (currentTime && currentTime - previousTime > 2 * 60 * 1000); // 时间差大于 2 分钟

            // 更新 previousTime
            previousTime = currentTime || previousTime;

            return {
              ...msg,
              id: id++,
              time: formattedTime,
              timeArray: msg.time, // 后端返回的原始时间数组
              showTime,
            };
          });

          this.setData({
            messages
          }, () => {
            this.scrollToBottom(); // 新增
          });
        }
      },
      fail: (error) => {
        console.error('获取历史消息失败:', error);
      },
    });
  },

  // 时间格式化方法
  formatServerTime(timeArray) {
    if (!timeArray || !Array.isArray(timeArray) || timeArray.length < 6) {
      return '未知时间';
    }

    // 1. 解析时间数组（确保数值类型）
    const [year, month, day, hour, minute] = timeArray.map(Number);

    // 2. 创建 Date 对象（假设后端返回的是本地时间）
    const date = new Date(year, month - 1, day, hour, minute);

    // 3. 手动格式化时间
    const pad = (n) => n.toString().padStart(2, '0'); // 补零函数
    const formattedHour = pad(date.getHours());
    const formattedMinute = pad(date.getMinutes());

    // 4. 日期判断逻辑
    const now = new Date();
    const isToday = (
      date.getFullYear() === now.getFullYear() &&
      date.getMonth() === now.getMonth() &&
      date.getDate() === now.getDate()
    );

    const isYesterday = (
      date.getFullYear() === now.getFullYear() &&
      date.getMonth() === now.getMonth() &&
      date.getDate() === now.getDate() - 1
    );

    // 5. 拼接结果
    if (isToday) {
      return `${formattedHour}:${formattedMinute}`;
    } else if (isYesterday) {
      return `昨天 ${formattedHour}:${formattedMinute}`;
    } else {
      return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${formattedHour}:${formattedMinute}`;
    }
  },


  // 处理接收到的用户消息
  handleReceivedMessage(data) {
    const {
      messages
    } = this.data;

    // 获取消息时间数组（假设data.time是后端返回的数组格式）
    const timeArray = data.time || [new Date().getFullYear(), new Date().getMonth() + 1, new Date().getDate(), 0, 0, 0];
    const formattedTime = this.formatServerTime(timeArray);


    // 计算是否显示时间
    let showTime = true;
    if (messages.length > 0) {
      const lastMsgTime = new Date(...messages[messages.length - 1].timeArray).getTime();
      const currentMsgTime = new Date(...timeArray).getTime();
      showTime = currentMsgTime - lastMsgTime > 2 * 60 * 1000;
    }

    const newMessage = {
      id: messages.length + 1,
      sender: data.senderId,
      content: data.content,
      time: formattedTime,
      timeArray,
      showTime,
    };
    this.setData({
      messages: [...messages, newMessage],
    }, () => this.scrollToBottom());
  },


  handleSystemMessage(data) {
    if (data.senderId === 'system') {
      this.handleUpdateMessageStatus(data.msgId, data.delieveStatus);
    }
  },

  //更新消息成功与否状态
  handleUpdateMessageStatus(msgId, delieveStatus) {
    const messages = this.data.messages;
    for (let i = messages.length - 1; i >= 0; i--) {
      // 检查 msgId 属性是否存在并且不是 null
      if (messages[i]?.msgId === msgId && messages[i]?.delieveStatus === 1) {
        messages[i].delieveStatus = delieveStatus;
        break;
      }
    }
    this.setData({
      messages
    });
  },


  // 发送消息
  sendMessage() {
    const {
      inputValue,
      messages,
      userId,
      chatId
    } = this.data;
    //防止发送空消息
    if (inputValue.trim() === '') return;

    // 生成临时ID（用于状态更新）
    const msgId = `temp_${Date.now()}`;
    const currentTime = new Date();
    const timeArray = [
      currentTime.getFullYear(),
      currentTime.getMonth() + 1,
      currentTime.getDate(),
      currentTime.getHours(),
      currentTime.getMinutes(),
      currentTime.getSeconds()
    ];
    const formattedTime = this.formatServerTime(timeArray);

    // 计算是否显示时间
    let showTime = true;
    if (messages.length > 0) {
      const lastMsgTime = new Date(...messages[messages.length - 1].timeArray).getTime();
      const currentMsgTime = new Date(...timeArray).getTime();
      console.log("上一条记录时间：{},当前：{}", lastMsgTime, currentTime);
      showTime = currentMsgTime - lastMsgTime > 2 * 60 * 1000;
    }

    // 发送消息（显示发送中状态）
    const newMessage = {
      id: messages.length + 1,
      delieveStatus: 1, //发送中
      msgId: msgId,
      sender: userId,
      content: inputValue,
      time: formattedTime,
      timeArray,
      showTime,
    };

    // 设置10秒超时定时器
    const timer = setTimeout(() => {
      //超时发送失败
      this.handleUpdateMessageStatus(msgId, 3);
    }, 10000);

    //更新消息列表，初始化输入框
    this.setData({
      messages: [...messages, newMessage],
      inputValue: '',
      [`timers.${msgId}`]: timer
    }, () => {
      this.scrollToBottom(); // 新增
    });

    // 发送消息
    app.globalData.ws.send({
      data: JSON.stringify({
        toUserId: chatId,
        msgId: msgId,
        content: inputValue,
      }),
      success: () => {
        console.log('消息已发送');
      },
      fail: (err) => {
        console.error('发送失败', err);
        this.handleUpdateMessageStatus(msgId, 3);
      }
    });
  },

  // 处理重新发送
  retrySend(e) {
    const msgId = e.currentTarget.dataset.msgid;
    const {
      messages
    } = this.data;
    const {
      chatId
    } = this.data;

    // 查找需要重发的消息
    const index = messages.findIndex(
      msg => msg.msgId === msgId && msg.delieveStatus === 3
    );

    if (index === -1) return;

    // 清除旧定时器
    const oldTimer = this.data.timers[msgId];
    if (oldTimer) {
      clearTimeout(oldTimer);
      this.setData({
        [`timers.${msgId}`]: null
      });
    }

    // 更新消息状态为发送中
    messages[index].delieveStatus = 1;
    this.setData({
      messages
    });

    // 设置新定时器
    const timer = setTimeout(() => {
      this.handleUpdateMessageStatus(msgId, 3);
    }, 10000);

    this.setData({
      [`timers.${msgId}`]: timer
    });

    // 重新发送消息
    const content = messages[index].content;
    app.globalData.ws.send({
      data: JSON.stringify({
        toUserId: chatId,
        msgId: msgId,
        content: content,
      }),
      success: () => {
        console.log('消息重新发送成功');
      },
      fail: (err) => {
        console.error('重新发送失败', err);
        this.handleUpdateMessageStatus(msgId, 3);
      }
    });
  },

  // 自动滚动到底部
  scrollToBottom() {
    if (this.data.messages.length === 0) return;

    const lastIndex = this.data.messages.length - 1;
    this.setData({
      scrollToId: `msg${lastIndex}`
    }, () => {
      // 确保滚动执行
      wx.nextTick(() => {
        this.setData({
          scrollToId: "" // 重置以便下次触发
        });
      });
    });
  },

  // 处理输入框变化
  onInput(e) {
    this.setData({
      inputValue: e.detail.value,
    });
  },

  // 返回上一页
  navigateBack() {
    wx.navigateBack();
  },

  // 处理更多操作
  handleMore() {
    // 处理更多操作
  },
});